#ifndef MANGOS_OBJECTACCESSOR_H
#define MANGOS_OBJECTACCESSOR_H

#include "Common.h"
#include "Platform/Define.h"
#include "Policies/Singleton.h"
#include <ace/Thread_Mutex.h>
#include <ace/RW_Thread_Mutex.h>
#include "Utilities/UnorderedMapSet.h"
#include "Policies/ThreadingModel.h"

#include "UpdateData.h"

#include "GridDefines.h"
#include "Object.h"
#include "Player.h"
#include "Corpse.h"

#include <set>
#include <list>

class Unit;
class WorldObject;
class Map;

template <class T>
class HashMapHolder
{
public:

    typedef UNORDERED_MAP< uint64, T* >   MapType;
    typedef ACE_RW_Thread_Mutex LockType;
    typedef ACE_Read_Guard<LockType> ReadGuard;
    typedef ACE_Write_Guard<LockType> WriteGuard;

    static void Insert(T* o)
    {
        WriteGuard guard(i_lock);
        m_objectMap[o->GetGUID()] = o;
    }

    static void Remove(T* o)
    {
        WriteGuard guard(i_lock);
        m_objectMap.erase(o->GetGUID());
    }

    static T* Find(ObjectGuid guid)
    {
        ReadGuard guard(i_lock);
        typename MapType::iterator itr = m_objectMap.find(guid.GetRawValue());
        return (itr != m_objectMap.end()) ? itr->second : NULL;
    }

    static MapType& GetContainer() { return m_objectMap; }

    static LockType& GetLock() { return i_lock; }

private:

    //Non instanceable only static
    HashMapHolder() {}

    static LockType i_lock;
    static MapType  m_objectMap;
};

class MANGOS_DLL_DECL ObjectAccessor : public MaNGOS::Singleton<ObjectAccessor, MaNGOS::ClassLevelLockable<ObjectAccessor, ACE_Thread_Mutex> >
{
    friend class MaNGOS::OperatorNew<ObjectAccessor>;

    ObjectAccessor();
    ~ObjectAccessor();
    ObjectAccessor(const ObjectAccessor &);
    ObjectAccessor& operator=(const ObjectAccessor &);

public:
    typedef UNORDERED_MAP<ObjectGuid, Corpse*> Player2CorpsesMapType;

    // Search player at any map in world and other objects at same map with `obj`
    // Note: recommended use Map::GetUnit version if player also expected at same map only
    static Unit* GetUnit(WorldObject const& obj, ObjectGuid guid);

    // Player access
    static Player* FindPlayer(ObjectGuid guid);         // if need player at specific map better use Map::GetPlayer
    static Player* FindPlayerByName(const char *name);
    static void KickPlayer(ObjectGuid guid);

    HashMapHolder<Player>::MapType& GetPlayers()
    {
        return HashMapHolder<Player>::GetContainer();
    }

    void SaveAllPlayers();

    // Corpse access
    Corpse* GetCorpseForPlayerGUID(ObjectGuid guid);
    static Corpse* GetCorpseInMap(ObjectGuid guid, uint32 mapid);
    void RemoveCorpse(Corpse *corpse);
    void AddCorpse(Corpse* corpse);
    void AddCorpsesToGrid(GridPair const& gridpair,GridType& grid,Map* map);
    Corpse* ConvertCorpseForPlayer(ObjectGuid player_guid, bool insignia = false);
    void RemoveOldCorpses();

    // For call from Player/Corpse AddToWorld/RemoveFromWorld only
    void AddObject(Corpse *object) { HashMapHolder<Corpse>::Insert(object); }
    void AddObject(Player *object) { HashMapHolder<Player>::Insert(object); }
    void RemoveObject(Corpse *object) { HashMapHolder<Corpse>::Remove(object); }
    void RemoveObject(Player *object) { HashMapHolder<Player>::Remove(object); }

private:

    Player2CorpsesMapType   i_player2corpse;

    typedef ACE_Thread_Mutex LockType;
    typedef MaNGOS::GeneralLock<LockType > Guard;

    LockType i_playerGuard;
    LockType i_corpseGuard;
};

#define sObjectAccessor ObjectAccessor::Instance()

#endif
